home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / video / xevil-1.000 / xevil-1 / game.C < prev    next >
C/C++ Source or Header  |  1995-08-22  |  64KB  |  2,402 lines
  1. // "game.C"
  2.  
  3. /*    Copyright (C) 1994,1995  Steve Hardt
  4.  
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 1, or (at your option)
  8.     any later version.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19.     Steve Hardt 
  20.     hardts@athena.mit.edu hardts@media.mit.edu
  21.     hardts@r4002.3dem.bioch.bcm.tmc.edu
  22.     2043 McClendon
  23.     Houston, TX 77030
  24. */
  25.  
  26. #ifndef NO_PRAGMAS
  27. #pragma implementation "game.h"
  28. #endif
  29.  
  30.  
  31. // Include Files
  32. extern "C" {
  33. #include <string.h>
  34. #include <stdio.h>
  35. }
  36.  
  37. #include <strstream.h>
  38. #include <iomanip.h>
  39.  
  40. #include "utils.h"
  41. #include "coord.h"
  42. #include "world.h"
  43. #include "id.h"
  44. #include "intel.h"
  45. #include "physical.h"
  46. #include "actual.h"
  47. #include "locator.h"
  48. #include "ui.h"
  49. #include "game.h"
  50.  
  51. extern "C" {
  52. #include <X11/Xresource.h>
  53. }
  54.  
  55.  
  56.  
  57. // Defines
  58. #define VERSION "1.4"
  59.  
  60. #ifdef XEVIL_KEYSET
  61. #define KEYSET_DEFAULT XEVIL_KEYSET
  62. #else
  63. #define KEYSET_DEFAULT UIdecmips
  64. #endif
  65.  
  66. #ifndef XEVIL_CLASS
  67. #define XEVIL_CLASS "XEvil"
  68. #endif
  69.  
  70. #define WORLD_ACROSS_MAX_DEFAULT 4
  71. #define WORLD_DOWN_MAX_DEFAULT 2
  72.  
  73. #define QUANTA_DEFAULT 40 // In milliseconds
  74. #define QUANTA_MAX 500
  75. #define EXTRA_TURNS 50
  76. #define DEMO_EXTRA_TURNS EXTRA_TURNS
  77. #define OTHER_INPUT_RESET 80
  78. #define HUMANS_NUM_DEFAULT 1
  79. #define ENEMIES_NUM_DEFAULT 3
  80. #define HUMAN_LIVES 3
  81. #define HUMAN_LIVES_SCENARIOS 10
  82. #define REFILL_TIME 200
  83. #define EXTRA_ITEMS_MULTIPLIER 8
  84. #define LEVEL_TIME 3000
  85. #define NEW_LEVEL_TIME 50
  86. #define LEVEL_ENEMIES_INITIAL 3 // Number of enemies on first level.
  87. #define LEVEL_ENEMIES_INCR 2
  88. #define LEVEL_TITLE_TIME 40
  89. #define DEMO_CUTOFF_TIME 400
  90. #define SCENARIO_BONUS_TIME 650
  91. #define SCENARIO_HIVE_ALIENS 15
  92. #define SCENARIO_FLAG_ENEMIES 15
  93. #define SCENARIO_LEMMINGS_ENEMIES 3
  94.  
  95. #define ALTAR_OF_SIN_CHANCE     10
  96. #define PISTOLS_PERCENT         .0004 
  97. #define CHAINSAWS_PERCENT       .0002
  98. #define M_GUNS_PERCENT          .0002
  99. #define SWAPPERS_PERCENT        .0002
  100. #define LANCERS_PERCENT         .0002
  101. #define FROG_GUNS_PERCENT       .0002
  102. #define F_THROWERS_PERCENT      .0002
  103. #define LAUNCHERS_PERCENT       .0002
  104. #define GRENADESS_PERCENT       .0002
  105. #define STARSS_PERCENT          .0002
  106. #define ROCKS_PERCENT           .001 
  107. #define WEIGHTS_PERCENT         .0002
  108. #define MED_KITS_PERCENT        .0003
  109. #define BOMBS_PERCENT           .0006
  110. #define N_SHIELDS_PERCENT       .00008
  111. #define T_SHIELDS_PERCENT       .00008
  112. #define TRANSMOGIFIERS_PERCENT  .00002
  113. #define DOPPELS_PERCENT         .00002 
  114.  
  115.  
  116. char *Game::wittySayings[WITTY_SAYINGS_NUM] = {
  117.   "If it moves it's a threat.  If it doesn't move it's a potential threat.",
  118.     "Happy, happy.  Joy, joy.",
  119.     "For the mother country!!!",
  120.     "Hi ho.  Hi ho.  It's off to kill we go.",
  121.     "Well, do you feel lucky, Punk?",
  122.     "Wake up, time to die.",
  123.     "Let's rock.",
  124.     "I love the smell of napalm in the morning.",
  125.     "How's it feel to be hunted?",
  126.     "Go ahead, make my day.",
  127.     "I'll be back.",
  128.     "Won't you be my neighbor?",
  129.     "3E.  We bring good things to death.",
  130.     "We come in peace.  (Shoot to kill.  Shoot to kill.)",
  131.     "Hey.  You can't do that.",
  132.     "I'm here to chew bubble-gum and kick ass.  And I'm all out of bubble-gum.",
  133.     "You're a useless asshole, Pogo-Man.",
  134.     "Settle down, Beavis.",
  135.     "Ho, ho, ho.  Now I have a machine gun.",
  136.     "Aren't you dead yet?",
  137.     "I don't give a fuck what you know.  I'm going to torture you anyway.",
  138.     "I'm hungry.  Let's get a taco.",
  139.     "I'm sorry, Dave.  I can't do that.",
  140.     "Violence is the only true form of communication.",
  141.     "Let the flames purify your soul!!!",
  142.     "Fuck me gently with a chainsaw.",
  143.     "He doesn't look like a quivering ball of white-hot canine fury.",
  144.     "Hackito ergo sum.",
  145.     "I'm singing in the rain...",
  146.     "Washin' the dog!!  Washin' the dog!!",
  147.     "ooooh.  That's gotta hurt.",
  148.     "Kids, don't try this at home.  We're trained professionals.",
  149.     "Oh, you want some of this?!  Fuck you!",
  150.     "Well, he shoulda' armed himself!",
  151.     "Fuck art.  Let's kill.",
  152.     "If you can't eat it or fuck it, kill it.",
  153.     "Skrotus lives in my fridge.",
  154.     "I love you.  You love me.  We're a happy family.",
  155.     "You always were an asshole, Gorman.",
  156.     "Change it dude.  This sucks.",
  157.     "The game of death, doom, and (more or less) ultimate destruction.",
  158.     "I think I'll just Dieeeeeee.",
  159.     "You know he'll feel that one in the morning.",
  160.     "I've had this ice-cream bar since I was a child.",
  161.     "Shut up or I will kill you.  I will physically kill you.",
  162.     "Better stop before someone gets hurt.",
  163.     "What??",
  164.     "Whoa!!",
  165.     "Jesus will love you if you give me money.",
  166.     "Evil.  It's not just for breakfast anymore.",
  167.     "XEvil.  The carpal tunnel game.",
  168.     "Violence.  It's not just the best policy.  It's the only policy.",
  169.     "Got ... to get ... to ... my arm.",
  170.     "Who's the lucky one?",
  171.     "Don't blink.  It would really suck if you blinked.",
  172.     "Here kitty, kitty, kitty.",
  173.     "Stay on target...",
  174.     "Do not taunt Happy-Fun-Ball.",
  175.     "Bring out the gimp.                            Gimp's sleepin.\nWell, I guess you'll just have to go wake him up now, won't you.",
  176.     "That's easy.",
  177.     "It's just a rabbit.",
  178.     "Ignorance is the number one cause of happiness.",
  179.     "What the heck's going on?  I thought I was a normal guy.",
  180.     "Oh, no.  It's K-k-k-ken c-c-c-coming to k-k-k-kill me.",
  181.     "You bloated sack of protoplasm.",
  182.     "The weak exist only to amuse the strong.",
  183.     "We're not hitch-hiking anymore.  We're riding.",
  184.     "No, sir.  I didn't like it.",
  185.     "Are we there yet?",
  186.     "Kurt Cobain spoke for my generation.",
  187.     "We're on a mission from God.",
  188.     "Oh, I'm a lumberjack and I'm ok...",
  189.     "I'm sorry.  You must have mistaken me for the clown that gives a damn.",
  190.     "Another visitor.  Stay awhile.  STAY FOREVER!!!!",
  191.     "I laughed.  I cried.  It was better than Cats.\nI'd see it again and again.",
  192.     "SPOON!!!",
  193.     "Only life can kill you.",
  194.     "That which does not kill us, hurts.",
  195.     "Hey, baby.  Wanna wrestle.",
  196.     "Fuck you and the horse you rode in on.",
  197.     "Spin, spin, spin, spin, spin, spin, spin...",
  198.     "Dope will get you through times of no money\nbetter than money will get you through times of no dope.",
  199.     "What he said.",
  200.     "Like, take off, eh.",
  201.     "Lord God, Leroy, that was the toughest meanest hippie I ever saw.",
  202.     "Happy thoughts.  Happy thoughts. Happy thoughts.",
  203.     "M*cr*s*ft:  Who need quality when you have marketing.",
  204.     "The proof is left as an exercise.",
  205.     "Ummm...  We have a problem.",
  206.     "Come see the violence inherent in the system.\nHelp! Help! I'm being repressed.",
  207.     "Hey, man, you a sniper?                                           Shut up.\nYou sure look like a sniper.                                      I said, shut up.",
  208.     "Oh, I'm sorry.  Did that hurt?",
  209.     "What me worry?",
  210.     "Nobody expects the Spanish Inquisition!!!",
  211.     "We are, we are, we are, we are, we are the engineers.\nWe can, we can, we can, we can demolish forty beers.",
  212.     "When in doubt, shoot the lawyer.",
  213.     "All that hate's gonna burn you up, boy.\nKeeps me warm.",
  214.     "He lives in that piece of paper?\nNo, you idiot.  He lives in a regular house.",
  215.     "I'll give you something to cry about.",
  216.     "It's not a bug, it's a feature.",
  217.     "Don't hate me because I'm beautiful.",
  218.     "What a great game of cards this is.",
  219.     "You're ugly and your mother dresses you funny.",
  220. };
  221.  
  222.  
  223.  
  224. char *Game::intelNames[INTEL_NAMES_NUM] = {
  225.   "Dr. Pain",
  226.   "Steve",
  227.   "hardts",
  228.   "James E. Tetazoo",
  229.   "Arnold",
  230.   "Victor the Cleaner",
  231.   "Hudson",
  232.   "Hicks",
  233.   "Twinkie Boy",
  234.   "Bob",
  235.   "Ben Bitdiddle",
  236.   "Beavis",
  237.   "Butt-Head",
  238.   "Fred",
  239.   "Mulch-Man",
  240.   "Mike",
  241.   "Tim",
  242.   "Peter",
  243.   "Alan",
  244.   "Neal",
  245.   "Tony",
  246.   "Asshole",
  247.   "Crazy Hairy",
  248.   "Spaceman Spiff",
  249.   "Kitty-Wench",
  250.   "Juker",
  251.   "Shrieks",
  252.   "Albert Lin",
  253.   "Jim Gouldstone",
  254.   "Steph",
  255.   "Paining",
  256.   "Dim",
  257.   "The Man",  
  258.   "Twinkie Girl",
  259.   "Mr. Buzzcut",  
  260.   "Sensei Steve",
  261.   "Ren",
  262.   "Stimpy",
  263.   "Mr. Horse",
  264.   "Dilbert",
  265.   "Dogbert",
  266.   "Gromit",
  267.   "The Tick",
  268.   "Fat Freddie",
  269.   "Phineas",
  270.   "Freewheelin Franklin",
  271.   "Doctor Who",
  272.   "Celery-Head-Man",
  273.   "Roo",
  274.   "Shwang",
  275.   "Leo",
  276.   "Smoothie",
  277.   "Hawaii Chick",
  278.   "Cowboy Steve",
  279.   "Outlaw Jim",
  280.   "Prick",
  281.   "Smack",
  282.   "Hello, Kitty",
  283.   "Wedge",
  284.   "Redshirt",
  285. };
  286.  
  287.  
  288.  
  289.  
  290. // Functions     
  291. void GameStats::report()
  292. {
  293.   if (numTurns % Game::REPORT_TIME == 0)
  294.     cout << "Turn " << numTurns << ":  Average time of turn:  " << 
  295.       aveTime << endl;
  296. }
  297.  
  298.  
  299.  
  300. void GameStats::clock()
  301. {
  302.   time_t oldPrevTime = prevTime;
  303.   time(&prevTime);    
  304.  
  305.   if (numTurns)
  306.     aveTime = (numTurns * aveTime + (prevTime - oldPrevTime)) / 
  307.       (numTurns + 1); 
  308.   
  309.   numTurns++;
  310. }
  311.  
  312.  
  313.  
  314. GameObjects::GameObjects(Boolean pol_correct)
  315. {
  316.   resetCalled = False;
  317.   for (int n = 0; n < HIGHEST; n++)
  318.     ids[n] = NULL;
  319.   polCorrect = pol_correct;
  320. }
  321.  
  322.  
  323.  
  324. void GameObjects::game_reset(const char *one_item,
  325.                  Boolean no_items,Boolean one_each)
  326. {
  327.   oneItem = one_item;
  328.   noItems = no_items;
  329.   oneEach = one_each;
  330.   resetCalled = True;
  331.   altarOfSinAlready = noItems; // If noItems, don't want an Altar of Sin.
  332.   
  333. //  level_reset(worldDim);
  334. }
  335.  
  336.  
  337.  
  338. void GameObjects::level_reset(const Dim &worldDim)
  339. {
  340.   // WARNING: GameObjects forgets about old items.  Not a memory leak, but 
  341.   // this may end up with more and more items coming into existence.
  342.  
  343.   // Initialization.
  344.   for (int n = 0; n < HIGHEST; n++)
  345.     {
  346.       maximums[n] = 0;
  347.       if (ids[n])
  348.     delete [] ids[n];
  349.     }
  350.  
  351.   // Normal case.
  352.   if (!strlen(oneItem) && !noItems && !oneEach)
  353.     {
  354.       int area = worldDim.rowMax * worldDim.colMax;
  355.  
  356.       maximums[PISTOLS] = (int)ceil(area * PISTOLS_PERCENT);
  357.       maximums[CHAINSAWS] = (int)ceil(area * CHAINSAWS_PERCENT);
  358.       maximums[M_GUNS] = (int)ceil(area * M_GUNS_PERCENT);
  359.       maximums[SWAPPERS] = (int)ceil(area * SWAPPERS_PERCENT);
  360.       maximums[LANCERS] = (int)ceil(area * LANCERS_PERCENT);
  361.       maximums[FROG_GUNS] = (int)ceil(area * FROG_GUNS_PERCENT);
  362.       maximums[F_THROWERS] = (int)ceil(area * F_THROWERS_PERCENT);
  363.       maximums[LAUNCHERS] = (int)ceil(area * LAUNCHERS_PERCENT);
  364.       maximums[GRENADESS] = (int)ceil(area * GRENADESS_PERCENT);
  365.       maximums[STARSS] = (int)ceil(area * STARSS_PERCENT);
  366.       maximums[ROCKS] = (int)ceil(area * ROCKS_PERCENT);
  367.       maximums[WEIGHTS] = (int)ceil(area * WEIGHTS_PERCENT);
  368.       maximums[MEDKITS] = (int)ceil(area * MED_KITS_PERCENT);
  369.       maximums[BOMBS] = (int)ceil(area * BOMBS_PERCENT);
  370.       maximums[N_SHIELDS] = (int)ceil(area * N_SHIELDS_PERCENT);
  371.       maximums[T_SHIELDS] = (int)ceil(area * T_SHIELDS_PERCENT);
  372.       maximums[TRANSMOGIFIERS] = (int)ceil(area * TRANSMOGIFIERS_PERCENT);
  373.       maximums[DOPPELS] = (int)ceil(area * DOPPELS_PERCENT);
  374.     }
  375.   // Only one item in the Game.
  376.   else if (strlen(oneItem))
  377.     {
  378.       if (!strcmp("rock",oneItem))
  379.     maximums[ROCKS] = 1;
  380.       else if (!strcmp("weight",oneItem))
  381.     maximums[WEIGHTS] = 1;
  382.       else if (!strcmp("med-kit",oneItem))
  383.     maximums[MEDKITS] = 1;
  384.       else if (!strcmp("bomb",oneItem))
  385.     maximums[BOMBS] = 1;
  386.       else if (!strcmp("chainsaw",oneItem))
  387.     maximums[CHAINSAWS] = 1;
  388.       else if (!strcmp("pistol",oneItem))
  389.     maximums[PISTOLS] = 1;
  390.       else if (!strcmp("machine-gun",oneItem))
  391.     maximums[M_GUNS] = 1;
  392.       else if (!strcmp("soul-swapper",oneItem))
  393.     maximums[SWAPPERS] = 1;
  394.       else if (!strcmp("lancer",oneItem))
  395.     maximums[LANCERS] = 1;
  396.       else if (!strcmp("frog-gun",oneItem))
  397.     maximums[FROG_GUNS] = 1;
  398.       else if (!strcmp("flame-thrower",oneItem))
  399.     maximums[F_THROWERS] = 1;
  400.       else if (!strcmp("launcher",oneItem))
  401.     maximums[LAUNCHERS] = 1;
  402.       else if (!strcmp("grenades",oneItem))
  403.     maximums[GRENADESS] = 1;
  404.       else if (!strcmp("stars",oneItem))
  405.     maximums[STARSS] = 1;
  406.       else if (!strcmp("n-shield",oneItem))
  407.     maximums[N_SHIELDS] = 1;
  408.       else if (!strcmp("t-shield",oneItem))
  409.     maximums[T_SHIELDS] = 1;
  410.       else if (!strcmp("transmogifier",oneItem))
  411.     maximums[TRANSMOGIFIERS] = 1;
  412.       else if (!strcmp("doppelganger",oneItem))
  413.     maximums[DOPPELS] = 1;
  414.     }
  415.   // One of each object.
  416.   else if (oneEach)
  417.     for (n = 0; n < HIGHEST; n++)
  418.       maximums[n] = 1;
  419.  
  420.   // Create the arrays of ids for each object type.
  421.   for (n = 0; n < HIGHEST; n++)
  422.     {
  423.       Id invalid;
  424.       ids[n] = new Id[maximums[n]];
  425.       for (int m = 0; m < maximums[n]; m++)
  426.     ids[n][m] = invalid;
  427.       // Explicitly initialize ids because different C++ compilers follow
  428.       // different rules about constructing elements of an array.
  429.     }
  430.  
  431.   // Compute actuals from maximums.
  432.   compute_actuals();
  433.  
  434.   // Somewhat of a hack.  Always want maximum number when using oneItem or
  435.   // oneEach.
  436.   if (strlen(oneItem) || oneEach)
  437.     for (n = 0; n < HIGHEST; n++)
  438.       actuals[n] = maximums[n];
  439. }
  440.  
  441.  
  442.  
  443. // Really should be a template.
  444. /* EFFECTS:  Choose a random number < maximum and make sure at least that many
  445.    of the item exist. */
  446. #define REFILL_HELPER(CLASS,which)\
  447. {\
  448.   int existsNum = 0;\
  449.   PhysicalP dummy;\
  450.   for (int m = 0; m < maximums[which]; m++)\
  451.     if (locator->lookup(dummy,ids[which][m]) == OL_NO_SIG)\
  452.       existsNum++;\
  453.   int newOnes = actuals[which] - existsNum;\
  454.   for (m = 0; newOnes > 0; m++)\
  455.     {\
  456.       assert(m < maximums[which]);\
  457.       if (locator->lookup(dummy,ids[which][m]) == OL_NOT_FOUND)\
  458.     { \
  459.       Pos pos = world->empty_rect(CLASS::get_size_max());\
  460.       PhysicalP p = new CLASS(world,locator,pos);\
  461.       assert(p);\
  462.       locator->add(p);\
  463.       ids[which][m] = p->get_id();\
  464.       newOnes--;\
  465.     }\
  466.     }\
  467. }
  468.  
  469. void GameObjects::refill(WorldP world,LocatorP locator)
  470. {
  471.   assert(resetCalled);
  472.  
  473.   if (!polCorrect && !altarOfSinAlready && 
  474.       Utils::choose(ALTAR_OF_SIN_CHANCE) == 0)
  475.     {
  476.       Pos pos = world->empty_rect(AltarOfSin::get_size_max());
  477.       PhysicalP p = new AltarOfSin(world,locator,pos); 
  478.       assert(p); 
  479.       locator->add(p); 
  480.       altarOfSinAlready = True;
  481.     }
  482.       
  483.   REFILL_HELPER(Rock,ROCKS);
  484.   REFILL_HELPER(Weight,WEIGHTS);
  485.   REFILL_HELPER(MedKit,MEDKITS);
  486.   REFILL_HELPER(Bomb,BOMBS);
  487.   REFILL_HELPER(Chainsaw,CHAINSAWS);
  488.   REFILL_HELPER(Pistol,PISTOLS);
  489.   REFILL_HELPER(MGun,M_GUNS);
  490.   REFILL_HELPER(Swapper,SWAPPERS);
  491.   REFILL_HELPER(Lancer,LANCERS);
  492.   REFILL_HELPER(FrogGun,FROG_GUNS);
  493.   REFILL_HELPER(FThrower,F_THROWERS);
  494.   REFILL_HELPER(Launcher,LAUNCHERS);
  495.   REFILL_HELPER(Grenades,GRENADESS);
  496.   REFILL_HELPER(Stars,STARSS);
  497.   REFILL_HELPER(NShield,N_SHIELDS);
  498.   REFILL_HELPER(TShield,T_SHIELDS);
  499.   REFILL_HELPER(Transmogifier,TRANSMOGIFIERS);
  500.   REFILL_HELPER(Doppel,DOPPELS);
  501. }
  502. #undef REFILL_HELPER
  503.  
  504.  
  505.  
  506. void GameObjects::compute_actuals()
  507. {
  508.   const int O_HIGHEST = HIGHEST - W_HIGHEST;
  509.  
  510.   // Initialize all actuals to 0.
  511.   for (int n = 0; n < HIGHEST; n++)
  512.     actuals[n] = 0;
  513.  
  514.   // Number of weapon and other classes to include in this level.
  515.   int wClassesNum = 2 + Utils::choose(5);  // 2 <= wClassesNum <= 6
  516.   int oClassesNum = 1 + Utils::choose(5);  // 1 <= oClassesNum <= 5
  517.   assert(wClassesNum < W_HIGHEST && oClassesNum < O_HIGHEST);
  518.  
  519.   // Rank the weapon and other classes.
  520.   int wRank[W_HIGHEST];
  521.   Utils::randomList(wRank,W_HIGHEST);
  522.   int oRank[O_HIGHEST];
  523.   Utils::randomList(oRank,O_HIGHEST);
  524.  
  525.   // Set actuals to be non-zero for the first wClassesNum in wRank.
  526.   for (n = 0; n < wClassesNum; n++)
  527.     {
  528.       int which = wRank[n];
  529.       actuals[which] = 
  530.     maximums[which] ? (Utils::choose(maximums[which]) + 1) : 0;
  531.     }
  532.  
  533.   // Set actuals to be non-zero for the first oClassesNum in oRank.
  534.   for (n = 0; n < oClassesNum; n++)
  535.     {
  536.       int which = oRank[n] + W_HIGHEST;
  537.       actuals[which] = 
  538.     maximums[which] ? (Utils::choose(maximums[which]) + 1) : 0;
  539.     }
  540. }
  541.  
  542.  
  543.  
  544. Game::Game(int *arg_c,char **arg_v)
  545.      : world(is_pol_correct(arg_c,arg_v)), 
  546.        locator(&world),
  547.        ui(arg_c,arg_v,&world,&locator,display_names(arg_c,arg_v),
  548.       is_pol_correct(arg_c,arg_v)),
  549.        gameObjects(is_pol_correct(arg_c,arg_v))
  550. { 
  551.   polCorrect = is_pol_correct(arg_c,arg_v);
  552.  
  553.   argc = arg_c;
  554.   argv = arg_v;
  555.  
  556.   gameOn = False;
  557.   demoOn = True;
  558.  
  559.   Timer t1(EXTRA_TURNS);
  560.   extraTimer = t1;
  561.   extraTime = False;
  562.  
  563.   Timer t11(DEMO_EXTRA_TURNS);
  564.   demoExtraTimer = t11;
  565.   demoExtraTime = False;
  566.  
  567.   Timer t2(OTHER_INPUT_RESET);
  568.   otherInputReset = t2;
  569.  
  570.   Timer t3(REFILL_TIME);
  571.   refillTimer = t3;
  572.   refillTimer.set();
  573.  
  574.   newLevelTime = False;
  575.  
  576.   Timer t5(LEVEL_TITLE_TIME);
  577.   levelTitleTimer = t5;
  578.   levelTitleTime = False;
  579.  
  580.   Timer t6(DEMO_CUTOFF_TIME);
  581.   demoCutoffTimer = t6;
  582.  
  583.   pause = False;
  584.   style = styleNext = UIsettings::LEVELS;
  585.   ui.set_style(style);
  586.  
  587.   scenarioOverride = HIGHEST; // I.e. ignore the override. 
  588.  
  589.   humansNum = 0;
  590.   humansNumNext = HUMANS_NUM_DEFAULT;
  591.   ui.set_humans_num(humansNumNext);
  592.  
  593.   enemiesNum = 0;
  594.   // Must be before parse_args.
  595.   enemiesNumNext = ENEMIES_NUM_DEFAULT;
  596.   ui.set_enemies_num(enemiesNumNext);
  597.  
  598.   enemiesRefill = enemiesRefillNext = False;
  599.   ui.set_enemies_refill(False);
  600.  
  601.   quanta = QUANTA_DEFAULT;
  602.   ui.set_quanta(quanta);
  603.  
  604.   humansPlayingPrev = enemiesPlayingPrev = 0;
  605.   enemyNameCount = 0;
  606.  
  607.   worldRooms.downMax = WORLD_DOWN_MAX_DEFAULT;
  608.   worldRooms.acrossMax = WORLD_ACROSS_MAX_DEFAULT;
  609.  
  610.   intelHarmless = False;
  611.   showStats = False;
  612.   dontAdvance = False;
  613.  
  614.   noItems = False;
  615.   oneEach = False;
  616.   oneItem = "";
  617.  
  618.   humanClass = A_None;
  619.  
  620.   parse_args(argc,argv);
  621.  
  622.   // Now in Game::reset.
  623.   // world.set_rooms_next(worldRooms);
  624.  
  625.   // Must be before first call to Ui::set_input.
  626.   process_x_resources(argc,argv);            
  627.   ui.set_input(0,UI_KEYS_RIGHT);
  628.  
  629.   intro();
  630.   locator.set_messages_ignore(True); // Must be after intro().
  631.  
  632.   demoCutoffTimer.set();
  633.   demo_setup();
  634. }
  635.  
  636.  
  637.  
  638. void Game::clock()
  639. {
  640.   Boolean shouldReset = False;
  641.  
  642.   ui_settings_check(shouldReset);
  643.   
  644.   // Must be before ui.clock().
  645.   if (!pause && !gameOn && otherInputReset.ready() && ui.other_input())
  646.     shouldReset = True;
  647.   
  648.   ui.clock();
  649.   
  650.   if (!pause)
  651.     {
  652.       /* Put after ui.clock so doesn't draw screen twice on reset.  Intel needs
  653.      to be clocked to get id so that ui can follow the id of the intel. */
  654.       if (shouldReset)
  655.     reset();
  656.       
  657.       if (gameOn)
  658.     {
  659.       if (levelTitleTime)
  660.         {
  661.           levelTitleTimer.clock();
  662.           if (levelTitleTimer.ready())
  663.         {
  664.           ui.unset_level_title();
  665.           levelTitleTime = False;
  666.         }
  667.         }
  668.       else
  669.         {
  670.           world.clock();
  671.           locator.clock();  
  672.           
  673.           reincarnations_check();
  674.           
  675.           int humansPlaying = locator.humans_playing();
  676.           int enemiesPlaying = locator.enemies_alive();
  677.           
  678.           if (humansPlaying != humansPlayingPrev)
  679.         {
  680.           humansPlayingPrev = humansPlaying;
  681.           ui.set_humans_playing(humansPlaying);
  682.         }
  683.           
  684.           if (enemiesPlaying != enemiesPlayingPrev)
  685.         {
  686.           enemiesPlayingPrev = enemiesPlaying;
  687.           ui.set_enemies_playing(enemiesPlaying);
  688.         }
  689.  
  690.           game_over_check(humansPlaying,enemiesPlaying);
  691.           
  692.           new_level_check(enemiesPlaying);
  693.           
  694.           if (showStats)
  695.         stats.report();
  696.           stats.clock();
  697.  
  698.           refill_check();
  699.  
  700.         } /* if (levelTitleTime) */
  701.     } /* if (gameOn) */
  702.       else
  703.     {
  704.       otherInputReset.clock();
  705.       demo_check();
  706.     }
  707.     } /* if (!pause) */
  708. }
  709.  
  710.  
  711.  
  712. void Game::ui_settings_check(Boolean &shouldReset)
  713. {
  714.   if (ui.settings_changed())
  715.     {
  716.       UIsettings settings;
  717.       UImask mask = ui.get_settings(settings);
  718.       
  719.       if (mask & UInewGame)
  720.     shouldReset = True;
  721.  
  722.       if (mask & UIquit)
  723.     {
  724.       print_stats();
  725.       exit(0);
  726.     }
  727.  
  728.       if (mask & UIhumansNum)
  729.     {
  730.       humansNumNext = min(settings.humansNum,Locator::HUMANS_MAX);
  731.       ui.set_humans_num(humansNumNext);
  732.     }
  733.  
  734.       if (mask & UIenemiesNum)
  735.     {
  736.       enemiesNumNext = min(settings.enemiesNum,Locator::ENEMIES_MAX);
  737.       ui.set_enemies_num(enemiesNumNext);
  738.     }
  739.  
  740.       if (mask & UIenemiesRefill)
  741.     {
  742.       enemiesRefillNext = settings.enemiesRefill;
  743.       ui.set_enemies_refill(enemiesRefillNext);
  744.     }
  745.  
  746.       if (mask & UIpause)
  747.     {
  748.       pause = settings.pause;
  749.       ui.set_pause(pause);
  750.     }
  751.  
  752.       if (mask & UIstyle)
  753.     {
  754.       ostrstream str;
  755.       styleNext = settings.style;
  756.       ui.set_style(settings.style);
  757.       switch (styleNext) {
  758.       case UIsettings::SCENARIOS:
  759.         str << "A number of different scenarios." << "\n"
  760.         << "You must complete each scenario to continue on to the "
  761.         << "next one." << ends;
  762.         break;
  763.       case UIsettings::LEVELS:
  764.         str << "Human player(s) fights through increasing levels of "
  765.         << "difficulty." << "\n" 
  766.         << "To complete a level you must kill all enemy players." 
  767.         << ends;
  768.         break;
  769.       case UIsettings::KILL:
  770.         str << "Every human and machine for him/her/itself." << ends;
  771.         break;
  772.       case UIsettings::DUEL:
  773.         str << "Human vs. human battle to the death." 
  774.         << "\n" << "Each human has 3 lives." << ends;
  775.         break;
  776.       case UIsettings::EXTENDED:
  777.         str << "Human vs. human battle to the death." 
  778.         << "\n" << "Unlimited lives." << ends;
  779.         break;
  780.       case UIsettings::TRAINING:
  781.         str << "One human plays alone.  Useful for learning the "
  782.         << "controls." << ends;
  783.         break;
  784.       };
  785.       locator.message_enq(str.str());
  786.     }
  787.       
  788.       if (mask & UIquanta)
  789.     {
  790.       quanta = settings.quanta;
  791.       if (quanta < 0)
  792.         quanta = 0;
  793.       if (quanta > QUANTA_MAX)
  794.         quanta = QUANTA_MAX;
  795.       ui.set_quanta(quanta);
  796.     }
  797.     }
  798. }
  799.  
  800.  
  801.  
  802. void Game::reincarnations_check()
  803. {
  804.   Incarnator iter(locator);
  805.   HumanP human;
  806.   while (human = iter())
  807.     {
  808.       PhysicalP obj = human_physical();
  809.       locator.add(obj);
  810.       human->reincarnate();
  811.       obj->set_intel(human);
  812.       
  813.       ostrstream msg;
  814.       msg << human->get_name() << " is back from the dead." << ends;
  815.       locator.message_enq(msg.str());
  816.     }
  817. }
  818.  
  819.  
  820.  
  821. void Game::game_over_check(int humansPlaying,int enemiesPlaying)
  822. {
  823.   if (!extraTime && 
  824.       (((style == UIsettings::SCENARIOS || 
  825.      style == UIsettings::LEVELS) && 
  826.     humansPlaying == 0) ||
  827.        (style == UIsettings::KILL && 
  828.     humansPlaying + enemiesPlaying <= 1) ||
  829.        ((style == UIsettings::DUEL || 
  830.      style == UIsettings::EXTENDED) &&
  831.     humansPlaying <= 1) ||
  832.        (style == UIsettings::TRAINING &&
  833.     humansPlaying == 0)))
  834.     {
  835.       // End the game.
  836.       extraTime = True;
  837.       extraTimer.set();
  838.     }
  839.  
  840.   if (extraTime && extraTimer.ready())
  841.     end_game();
  842.   if (extraTime)
  843.     extraTimer.clock();
  844. }      
  845.  
  846.  
  847.  
  848. void Game::new_level_check(int enemiesPlaying)
  849. {
  850.   if (style == UIsettings::SCENARIOS)
  851.     {
  852.       if (!newLevelTime && scenario == EXTERMINATE && enemiesPlaying == 0)
  853.     {
  854.       newLevelTime = True;
  855.       newLevelTimer.set(NEW_LEVEL_TIME);
  856.     }
  857.       else if (scenario == BONUS)
  858.     {
  859.       // Count number of Frogs still alive.
  860.       int remaining = 0;
  861.       for (int n = 0; n < SCENARIO_BONUS_FROGS; n++)
  862.         {
  863.           PhysicalP p = locator.lookup(frogs[n]);
  864.           if (p && p->alive())
  865.         remaining++;
  866.         }
  867.       
  868.       // Update Ui.
  869.       if (remaining != frogsRemaining)
  870.         {
  871.           frogsRemaining = remaining;
  872.           ostrstream str;
  873.           str << "[" << level << "] BONUS LEVEL\nfrogs remaining: " 
  874.         << remaining << ends;
  875.           ui.set_level(str.str());
  876.           delete str.str();
  877.  
  878.           // Will only be called once per level.
  879.           if (frogsRemaining == 0)
  880.         {
  881.           ostrstream ostr;
  882.           ostr << "***** You must feel proud of yourself for killing all those defenseless frogs. *****" << ends;
  883.           locator.message_enq(ostr.str());
  884.           assert(newLevelTime);
  885.           newLevelTimer.set(NEW_LEVEL_TIME);
  886.         }
  887.         }      
  888.     }
  889.       else if (!newLevelTime && scenario == HIVE)
  890.     {
  891.       PhysicalP xit = locator.lookup(xitId);
  892.       assert(xit); // The Xit should never be destroyed.
  893.       if (((TouchableP)xit)->wasTouched())
  894.         {
  895.           newLevelTimer.set(0);
  896.           newLevelTime = True;
  897.         }
  898.     }
  899.       else if (!newLevelTime && scenario == FLAG)
  900.     {
  901.       int fRemaining = 0;
  902.       for (int n = 0; n < SCENARIO_FLAG_FLAGS; n++)
  903.         {
  904.           PhysicalP p = locator.lookup(flagIds[n]);
  905.           if (p)
  906.         {
  907.           fRemaining++;
  908.           if (((TouchableP)p)->wasTouched())
  909.             off_clock_kill(p);
  910.         }
  911.         }
  912.       if (fRemaining == 0) // All flags are gone, so end level.
  913.         {
  914.           newLevelTime = True;
  915.           newLevelTimer.set(0);
  916.         }
  917.       if (fRemaining != flagsRemaining)
  918.         {
  919.           flagsRemaining = fRemaining;
  920.           ostrstream levelStr;
  921.           levelStr << "[" << level << "] COLLECT " << SCENARIO_FLAG_FLAGS
  922.         << " FLAGS\nremaining: " << flagsRemaining << ends;
  923.           ui.set_level(levelStr.str()); 
  924.           delete levelStr.str();
  925.         }
  926.     }
  927.       else if (!newLevelTime && scenario == LEMMINGS)
  928.     {
  929.       // NOTE: Lemming counts may be a little screwy if other Physicals
  930.       // have soul-swapped with some of the Lemmings.  
  931.       
  932.       HomeP home = (HomeP)locator.lookup(homeId);
  933.       TrapdoorP trapdoor = (TrapdoorP)locator.lookup(trapdoorId);
  934.       assert(home && trapdoor);
  935.  
  936.       // Count lemmings out, active, and safe.
  937.       IntelId *lemmings; // Care about LemmingIntels, not Lemmings.
  938.       int lemOut = trapdoor->get_lemmings_out(lemmings);
  939.       int lemSafe = home->get_lemmings_safe();
  940.       int lemActive = 0;
  941.       for (int n = 0; n < lemOut; n++)
  942.         {
  943.           IntelP lemmingIntel = locator.lookup(lemmings[n]);          
  944.           if (lemmingIntel)
  945.         {
  946.           PhysicalP lemming = locator.lookup(lemmingIntel->get_id());
  947.           if (lemming && lemming->alive())
  948.             lemActive++;
  949.         }
  950.         }
  951.  
  952.       // Number Dead depends only on Out, Safe, and Active, so don't bother
  953.       // keeping it from turn to turn.  I.e. no Game::lemmingsDead.
  954.       int lemDead = lemOut - lemSafe - lemActive;
  955.       
  956.       // Update the Ui if necessary.
  957.       if (lemSafe != lemmingsSafe || lemOut != lemmingsOut ||
  958.           lemActive != lemmingsActive)
  959.         {
  960.           lemmingsSafe = lemSafe;
  961.           lemmingsOut = lemOut;
  962.           lemmingsActive = lemActive;
  963.           ostrstream levelStr;
  964.           levelStr << "[" << level << "] SAVE " 
  965.         << SCENARIO_LEMMINGS_NEED << " LEMS\n" 
  966.           << "out: " << lemmingsOut << " safe: " << lemmingsSafe
  967.             << " dead: " << lemDead
  968.               << ends;
  969.           ui.set_level(levelStr.str()); 
  970.           delete levelStr.str();
  971.         }
  972.  
  973.       // New level if enough lemmings are safe or too many are dead.
  974. //      if ((lemOut == SCENARIO_LEMMINGS_LEMMINGS && lemActive == 0) ||
  975. //          lemSafe >= SCENARIO_LEMMINGS_NEED)
  976.       if (lemDead > SCENARIO_LEMMINGS_LEMMINGS - SCENARIO_LEMMINGS_NEED
  977.           || lemSafe >= SCENARIO_LEMMINGS_NEED)
  978.         {
  979.           if (lemSafe < SCENARIO_LEMMINGS_NEED)
  980.         {
  981.           ostrstream msg;
  982.           msg << "YOU FAILED TO SAVE " << SCENARIO_LEMMINGS_NEED
  983.             << " LEMS.\nTry this level again." << ends;
  984.           locator.message_enq(msg.str());
  985.  
  986.           dontAdvance = True;
  987.         }
  988.  
  989.           newLevelTime = True;
  990.           newLevelTimer.set(NEW_LEVEL_TIME);
  991.         }          
  992.     }
  993.       else if (!newLevelTime && scenario == FIRE_DEMON 
  994.            && enemiesPlaying == 0)
  995.     {
  996.       newLevelTime = True;
  997.       newLevelTimer.set(NEW_LEVEL_TIME);
  998.     }
  999.     }
  1000.  
  1001.  
  1002.   // LEVELS game style.
  1003.   if (!newLevelTime && style == UIsettings::LEVELS && 
  1004.       enemiesPlaying == 0)
  1005.     {
  1006.       newLevelTime = True;
  1007.       newLevelTimer.set(NEW_LEVEL_TIME);
  1008.     }
  1009.  
  1010.  
  1011.   // Call new_level() when newLevelTimer has expired.
  1012.   if (newLevelTime)
  1013.     {
  1014.       if (newLevelTimer.ready())
  1015.     {
  1016.       newLevelTime = False;
  1017.       new_level();
  1018.     }
  1019.       else
  1020.     newLevelTimer.clock();
  1021.     }
  1022. }
  1023.  
  1024.  
  1025.  
  1026. void Game::refill_check()
  1027. {
  1028.   if (refillTimer.ready())
  1029.     {
  1030.       if (!(style == UIsettings::SCENARIOS && scenario == BONUS))
  1031.     gameObjects.refill(&world,&locator);
  1032.       
  1033.       if (enemiesRefill &&
  1034.       (style == UIsettings::KILL || 
  1035.        style == UIsettings::DUEL
  1036.        || style == UIsettings::EXTENDED))
  1037.     refill_enemies();
  1038.       else if (style == UIsettings::SCENARIOS && scenario == HIVE)
  1039.     hive_refill_enemies();
  1040.       else if (style == UIsettings::SCENARIOS && scenario == FLAG)
  1041.     flag_refill_enemies();
  1042.       else if (style == UIsettings::SCENARIOS && scenario == LEMMINGS)
  1043.     lemmings_refill_enemies();
  1044.  
  1045.       refillTimer.set();
  1046.     }
  1047.   refillTimer.clock();
  1048. }
  1049.  
  1050.  
  1051.  
  1052. void Game::demo_check()
  1053. {
  1054.   if (demoOn)
  1055.     {
  1056.       if (!demoExtraTime && locator.enemies_alive() <= 1)
  1057.     {
  1058.       demoExtraTimer.set();
  1059.       demoExtraTime = True;
  1060.     }
  1061.       
  1062.       // Start new demo.
  1063.       if (demoCutoffTimer.ready() || 
  1064.       (demoExtraTime && demoExtraTimer.ready()))
  1065.     {
  1066.       demoCutoffTimer.set();
  1067.       demoExtraTime = False;
  1068.       locator.reset();
  1069.       ui.reset();
  1070.       demo_setup();
  1071.     }
  1072.       
  1073.       demoCutoffTimer.clock();
  1074.       demoExtraTimer.clock();
  1075.       world.clock();
  1076.       locator.clock();
  1077.     }        
  1078. }
  1079.  
  1080.  
  1081.  
  1082. PhysicalP Game::human_physical()
  1083. {
  1084.   PhysicalP obj;
  1085.   int which = -1;
  1086.   if (humanClass == A_None)
  1087.     which = Utils::choose(3);
  1088.  
  1089.   if (humanClass == A_Enforcer)
  1090.     {
  1091.       Pos pos = world.empty_rect(Enforcer::get_size_max());
  1092.       obj = new Enforcer(&world,&locator,pos);
  1093.     }
  1094.   else if (humanClass == A_Frog)
  1095.     {
  1096.       Id invalid;
  1097.       Pos pos = world.empty_rect(Frog::get_size_max());
  1098.       obj = new Frog(&world,&locator,pos,invalid);
  1099.     }
  1100.   else if (humanClass == A_Hero || which == 0)
  1101.     {
  1102.       Pos pos = world.empty_rect(Hero::get_size_max());
  1103.       obj = new Hero(&world,&locator,pos);
  1104.     }
  1105.   else if (humanClass == A_Ninja || which == 1)
  1106.     {
  1107.       Pos pos = world.empty_rect(Ninja::get_size_max());
  1108.       obj = new Ninja(&world,&locator,pos);
  1109.     }
  1110.   else if (humanClass == A_ChopperBoy || which == 2)
  1111.     {
  1112.       Pos pos = world.empty_rect(ChopperBoy::get_size_max());
  1113.       obj = new ChopperBoy(&world,&locator,pos);
  1114.     }
  1115.   else if (humanClass == A_Alien)
  1116.     {
  1117.       Pos pos = world.empty_rect(Alien::get_size_max());
  1118.       obj = new Alien(&world,&locator,pos);
  1119.     }
  1120.   else if (humanClass == A_FireDemon)
  1121.     {
  1122.       Pos pos = world.empty_rect(FireDemon::get_size_max());
  1123.       obj = new FireDemon(&world,&locator,pos);
  1124.     }
  1125.   else
  1126.     assert(0);
  1127.  
  1128.  
  1129.   assert(obj);
  1130.   return obj;
  1131. }
  1132.  
  1133.  
  1134.  
  1135. // The default set of classes to be used by enemy_physical.
  1136. ClassId Game::defaultChoosable[DEFAULT_CHOOSABLE_NUM] =
  1137. { A_Ninja,A_Hero,A_ChopperBoy,A_Enforcer,A_Alien,A_FireDemon};
  1138.  
  1139. int Game::defaultChoosableWeights[DEFAULT_CHOOSABLE_NUM] =
  1140. { 3,      3,     2,           1,         1,     0};
  1141.  
  1142.  
  1143. PhysicalP Game::enemy_physical(ClassId *choosable,int choosableNum)
  1144. {
  1145.   int localWeights[DEFAULT_CHOOSABLE_NUM];
  1146.   int *weights;
  1147.  
  1148.   if (choosableNum == 0) // Use defaults
  1149.     {
  1150.       choosable = defaultChoosable;
  1151.       choosableNum = DEFAULT_CHOOSABLE_NUM;
  1152.       weights = defaultChoosableWeights;
  1153.     }
  1154.   else
  1155.     {
  1156.       assert(choosable);
  1157.       weights = localWeights;
  1158.       // Get weights from defaultChoosableWeights.
  1159.       for (int n = 0; n < choosableNum; n++)
  1160.     for (int m = 0; m < DEFAULT_CHOOSABLE_NUM; m++)
  1161.       if (choosable[n] == defaultChoosable[m])
  1162.         weights[n] = defaultChoosableWeights[m];
  1163.     }
  1164.  
  1165.   int weightsSum = 0;
  1166.   for (int n = 0; n < choosableNum; n++)
  1167.     weightsSum += weights[n];
  1168.   
  1169.   int choice = Utils::choose(weightsSum);
  1170.   int weightBelow = 0;
  1171.   for (n = 0; n < choosableNum; n++)
  1172.     {
  1173.       weightBelow += weights[n];
  1174.       if (choice < weightBelow)
  1175.     return enemy_physical(choosable[n]);
  1176.     }
  1177.   assert(0);
  1178.   return NULL;
  1179. }
  1180.  
  1181.  
  1182.  
  1183. PhysicalP Game::enemy_physical(ClassId classId)
  1184. {
  1185.   assert(classId == A_Ninja || classId == A_Hero 
  1186.      || classId == A_ChopperBoy || classId == A_Enforcer 
  1187.      || classId == A_Alien || classId == A_Frog 
  1188.      || classId == A_FireDemon);
  1189.  
  1190.   PhysicalP obj;
  1191.   switch (classId) {
  1192.   case A_Ninja:
  1193.     {
  1194.       Pos pos = world.empty_rect(Ninja::get_size_max());
  1195.       obj = new Ninja(&world,&locator,pos);
  1196.     }
  1197.     break;
  1198.   case A_Hero:
  1199.     {
  1200.       Pos pos = world.empty_rect(Hero::get_size_max());
  1201.       obj = new Hero(&world,&locator,pos);
  1202.     }
  1203.     break;
  1204.   case A_ChopperBoy:
  1205.     {
  1206.       Pos pos = world.empty_rect(ChopperBoy::get_size_max());
  1207.       obj = new ChopperBoy(&world,&locator,pos);
  1208.     }
  1209.     break;
  1210.   case A_Enforcer:
  1211.     {
  1212.       Pos pos = world.empty_rect(Enforcer::get_size_max());
  1213.       obj = new Enforcer(&world,&locator,pos);
  1214.     }
  1215.     break;
  1216.   case A_Alien:
  1217.     {
  1218.       Pos pos = world.empty_rect(Alien::get_size_max());
  1219.       obj = new Alien(&world,&locator,pos);
  1220.     }
  1221.     break;
  1222.   case A_Frog:
  1223.     {
  1224.       Id invalid;
  1225.       Pos pos = world.empty_rect(Frog::get_size_max());
  1226.       obj = new Frog(&world,&locator,pos,invalid);
  1227.     }
  1228.     break;
  1229.   case A_FireDemon:
  1230.     {
  1231.       Pos pos = world.empty_rect(FireDemon::get_size_max());
  1232.       obj = new FireDemon(&world,&locator,pos);
  1233.     }
  1234.     break;
  1235.   default:
  1236.     assert(0);
  1237.   }
  1238.  
  1239.   assert(obj);
  1240.   return obj;
  1241. }
  1242.  
  1243.  
  1244.  
  1245. Game::Scenario Game::choose_scenario()
  1246. {
  1247.   if (scenarioOverride != HIGHEST)
  1248.     return scenarioOverride;
  1249.   else
  1250.     return (Scenario)Utils::choose(HIGHEST);
  1251. }
  1252.  
  1253.  
  1254.  
  1255. void Game::end_game()
  1256. {
  1257.   gameOn = False;
  1258.  
  1259.   ostrstream winners;
  1260.   winners << "Game Over.  Winners: ";
  1261.   int winnersNum = 0;
  1262.   for (int n = 0; n < humansNum; n++)
  1263.     {
  1264.       HumanP human = locator.get_human(n);
  1265.  
  1266.       if (human->alive() || human->get_lives() == IT_INFINITE_LIVES 
  1267.       || human->get_lives() > 0)
  1268.     {
  1269.       winners << human->get_name() << "(" << human->get_human_kills() 
  1270.         << " human(s), " << human->get_enemy_kills() << " machine(s)) ";
  1271.       winnersNum++;
  1272.     }
  1273.     }
  1274.   if (winnersNum)
  1275.     {
  1276.       winners << ends;
  1277.       locator.message_enq(winners.str());
  1278.     }
  1279.   else if (locator.enemies_alive())
  1280.     {
  1281.       ostrstream str;
  1282.       if (humansNum)
  1283.     str << "Ha, ha.  You puny fleshlings can never defeat your " <<
  1284.       "computer masters." << ends;
  1285.       else
  1286.     str << "The game is over." << ends;
  1287.       locator.message_enq(str.str());
  1288.     }
  1289.   else
  1290.     {
  1291.       ostrstream str;
  1292.       if (polCorrect)
  1293.     str << "Game Over.  Everybody is dead.  You all suck." << ends;
  1294.       else
  1295.     str << "Game Over.  Everybody is dead." << ends;
  1296.       locator.message_enq(str.str());
  1297.     }
  1298.   
  1299.   otherInputReset.set();
  1300. }
  1301.  
  1302.  
  1303.  
  1304. void Game::new_level(Boolean fromReset)
  1305. {
  1306.   // dontAdvance should only be used for SCENARIOS game style.
  1307.   assert(!dontAdvance || style == UIsettings::SCENARIOS);
  1308.  
  1309.   if (!dontAdvance)
  1310.     level++;
  1311.  
  1312.   if (level > levelHighest)
  1313.     levelHighest = level;
  1314.  
  1315.   ostrstream lStr;       // For level box on the side of the Ui.
  1316.   ostrstream lTitleStr;  // For Ui title screen.
  1317.  
  1318.   // Switch on the current game style.
  1319.   switch(style) {
  1320.   case UIsettings::SCENARIOS:
  1321.     {
  1322.       if (!dontAdvance)
  1323.     scenario = choose_scenario();
  1324.       else
  1325.     dontAdvance = False;
  1326.  
  1327.       // Switch on the possible scenarios.
  1328.       switch(scenario) {
  1329.       case EXTERMINATE:
  1330.     world.set_rooms_next(worldRooms);
  1331.     break;
  1332.       case BONUS:
  1333.     {
  1334.       Rooms rooms(2,1);
  1335.       world.set_rooms_next(rooms);
  1336.     }
  1337.     break;
  1338.       case HIVE:
  1339.     {
  1340.       Rooms rooms(5,5);
  1341.       world.set_rooms_next(rooms);
  1342.     }
  1343.     break;
  1344.       case FLAG:
  1345.     {
  1346.       Rooms rooms(3,6);
  1347.       world.set_rooms_next(rooms);
  1348.     }
  1349.     break;
  1350.       case LEMMINGS:
  1351.     {
  1352.       Rooms rooms(1,4);
  1353.       world.set_rooms_next(rooms);
  1354.     }
  1355.     break;
  1356.       case FIRE_DEMON:
  1357.     {
  1358.       Rooms rooms(2,2);
  1359.       world.set_rooms_next(rooms);
  1360.     }
  1361.     break;
  1362.       default:
  1363.     assert(0);
  1364.     break;
  1365.       };
  1366.  
  1367.       world.reset();
  1368.       
  1369.  
  1370.       // Clean up all Physicals in the Game.  World must be reset so 
  1371.       // that human players can be moved to the inside of the world.
  1372.       PhysicalIter pIter(locator);
  1373.       PhysicalP p;
  1374.       while (p = pIter())
  1375.     {
  1376.       IntelP intel = p->get_intel();
  1377.       Boolean saveMe = False;
  1378.  
  1379.       // Save Human controlled physicals.
  1380.       if (intel && intel->is_human())
  1381.         saveMe = True;
  1382.  
  1383.       // Save Machines that are slaves of Humans.
  1384.       if (intel && !intel->is_human())
  1385.         {
  1386.           IntelP master = 
  1387.         locator.lookup(((MachineP)intel)->get_master_intel_id());
  1388.           if (master && master->is_human())
  1389.         saveMe = True;
  1390.         }
  1391.  
  1392.       // Move to a new location inside the World.
  1393.       if (saveMe)
  1394.         {
  1395.           assert(p->is_moving());
  1396.           const Area &area = p->get_area();
  1397.           Size size;
  1398.           Pos pos;
  1399.           area.get_rect(pos,size);
  1400.           ((MovingP)p)->relocate(world.empty_rect(size));
  1401.         }
  1402.       // Kill Items not held by Human players.
  1403.       else if (p->is_item())
  1404.         {
  1405.           Id holderId = ((ItemP)p)->get_holder_id();
  1406.           PhysicalP holder = locator.lookup(holderId);
  1407.           if (!(holder && (intel = holder->get_intel())
  1408.             && intel->is_human()))
  1409.         off_clock_kill(p);
  1410.         }
  1411.       // Quietly kill everything else, ha, ha, ha.
  1412.       else
  1413.         off_clock_kill(p);
  1414.     }
  1415.  
  1416.       // Switch on the possible scenarios.
  1417.       switch(scenario) {
  1418.       case EXTERMINATE:
  1419.     {
  1420.       lTitleStr << "[" << level << "] EXTERMINATE" << ends;
  1421.       lStr << "[" << level << "] EXTERMINATE\nKill all machines." << ends;
  1422.       enemiesNum += LEVEL_ENEMIES_INCR;
  1423.       for (int m = 0; m < enemiesNum; m++)
  1424.         create_enemy();
  1425.     }
  1426.     break;
  1427.       case BONUS:
  1428.     {
  1429.       for (int n = 0; n < SCENARIO_BONUS_FROGS; n++)
  1430.         {
  1431.           PhysicalP p = create_enemy(enemy_physical(A_Frog));
  1432.           frogs[n] = p->get_id();
  1433.         }
  1434.       frogsRemaining = SCENARIO_BONUS_FROGS;
  1435.       newLevelTimer.set(SCENARIO_BONUS_TIME);
  1436.       newLevelTime = True;
  1437.       lTitleStr << "[" << level << "] BONUS LEVEL" << ends;
  1438.       lStr << "[" << level << "] BONUS LEVEL\nfrogs remaining: " 
  1439.         << SCENARIO_BONUS_FROGS << ends;
  1440.     }
  1441.     break;
  1442.       case HIVE:
  1443.     {
  1444.       // Aliens are created in Game::clock.
  1445.       lTitleStr << "[" << level << "] HIVE" << ends;
  1446.       lStr << "[" << level << "] HIVE.\nFind the exit." << ends;
  1447.       
  1448.       // Create the Xit.
  1449.       Pos pos = world.empty_accessible_rect(Xit::get_size_max());
  1450.       PhysicalP p = new Xit(&world,&locator,pos);
  1451.       assert(p);
  1452.       locator.add(p);
  1453.       xitId = p->get_id();
  1454.     }
  1455.     break;
  1456.       case FLAG:
  1457.     {
  1458.       for (int n = 0; n < SCENARIO_FLAG_FLAGS; n++)
  1459.         {
  1460.           Pos pos = world.empty_accessible_rect(Flag::get_size_max());
  1461.           PhysicalP p = new Flag(&world,&locator,pos);
  1462.           assert(p);
  1463.           locator.add(p);
  1464.           flagIds[n] = p->get_id();
  1465.         }
  1466.       flagsRemaining = SCENARIO_FLAG_FLAGS;
  1467.       lTitleStr << "[" << level << "] CAPTURE THE FLAG" << ends;
  1468.       lStr << "[" << level << "] COLLECT " << SCENARIO_FLAG_FLAGS 
  1469.         << " FLAGS.\nremaining: " << SCENARIO_FLAG_FLAGS << ends;
  1470.     }
  1471.     break;
  1472.       case LEMMINGS:
  1473.     {
  1474.       // Know these area is open because they are within the 
  1475.       // (OBJECT_COL_MAX,OBJECT_ROW_MAX) margain around the World edge.
  1476.       Size worldSize = world.get_size();
  1477.       Size homeSize = Home::get_size();
  1478.       Pos homePos(worldSize.width - 12 * WSQUARE_WIDTH - homeSize.width,
  1479.               worldSize.height - WSQUARE_HEIGHT - homeSize.height);
  1480.       PhysicalP home = 
  1481.         new Home(&world,&locator,homePos);
  1482.       assert(home);
  1483.       locator.add(home);
  1484.       homeId = home->get_id();
  1485.       
  1486.  
  1487.       // Create Trapdoor after Home because it needs homeId.
  1488.       Pos trapdoorPos(3*WSQUARE_WIDTH,WSQUARE_HEIGHT);
  1489.       PhysicalP trapdoor = 
  1490.         new Trapdoor(&world,&locator,trapdoorPos,homeId);
  1491.       locator.add(trapdoor);
  1492.       trapdoorId = trapdoor->get_id();
  1493.       
  1494.       lemmingsSafe = lemmingsOut = lemmingsActive = 0;
  1495.       lTitleStr << "[" << level << "] LEMS" << ends;
  1496.       lStr << "[" << level << "] SAVE " 
  1497.         << SCENARIO_LEMMINGS_NEED << " LEMS\n" 
  1498.           << "out: 0 safe: 0 dead: 0" << ends;
  1499.     }
  1500.     break;
  1501.       case FIRE_DEMON:
  1502.     {
  1503.       lTitleStr << "[" << level << "] FIRE DEMON" << ends;
  1504.       lStr << "[" << level << "] Kill the Fire Demon." << ends;
  1505.       create_enemy(enemy_physical(A_FireDemon));
  1506.     }
  1507.     break;
  1508.       default:
  1509.     assert(0);
  1510.     break;
  1511.       };
  1512.     }
  1513.     break;
  1514.     
  1515.   case UIsettings::LEVELS:
  1516.     {
  1517.       // World stays the same size.
  1518.       if (!fromReset)
  1519.     world.reset();
  1520.       lTitleStr << "Level: " << level << ends;
  1521.       lStr << "Level: " << level << ends;
  1522.       enemiesNum += LEVEL_ENEMIES_INCR;
  1523.       for (int m = 0; m < enemiesNum; m++)
  1524.     create_enemy();
  1525.     }
  1526.     break;
  1527.  
  1528.   case UIsettings::KILL:
  1529.   case UIsettings::DUEL:
  1530.   case UIsettings::EXTENDED:
  1531.   case UIsettings::TRAINING:
  1532.     {
  1533.       // World stays the same size.
  1534.       if (!fromReset)
  1535.     world.reset();
  1536.       lTitleStr << "Level: " << level << ends;
  1537.       lStr << "Level: " << level << ends;
  1538.       newLevelTimer.set(LEVEL_TIME);
  1539.       newLevelTime = True;
  1540.  
  1541.       // NOTE: Do not kill off extra Physical objects for these styles.
  1542.     }
  1543.     break;
  1544.   };
  1545.   
  1546.   gameObjects.level_reset(world.get_dim());
  1547.  
  1548.   // No gameObjects for BONUS scenario.
  1549.   if (!(style == UIsettings::SCENARIOS && scenario == BONUS))
  1550.     gameObjects.refill(&world,&locator);
  1551.  
  1552.   ui.set_level_title(lTitleStr.str());
  1553.   ui.set_level(lStr.str());
  1554.   delete lTitleStr.str();
  1555.   delete lStr.str();
  1556.  
  1557.   levelTitleTime = True;
  1558.   levelTitleTimer.set();
  1559. }
  1560.  
  1561.  
  1562.  
  1563. void Game::reset()
  1564. {
  1565.   demoOn = False;
  1566.   locator.set_messages_ignore(False);
  1567.   if (gameOn)
  1568.     end_game();
  1569.  
  1570.   extraTime = False;
  1571.   levelTitleTime = False;
  1572.   newLevelTime = False;
  1573.   enemyNameCount = 0;
  1574.   enemiesRefill = enemiesRefillNext;
  1575.   humansNum = humansNumNext;
  1576.   enemiesNum = enemiesNumNext;
  1577.   style = styleNext;
  1578.   level = 0; // So will start out at 1.
  1579.   levelHighest = 0;
  1580.  
  1581.   locator.reset();
  1582.   ui.reset();
  1583.  
  1584.   if (style != UIsettings::SCENARIOS)
  1585.     {
  1586.       world.set_rooms_next(worldRooms);
  1587.       world.reset();
  1588.     }
  1589.   // else the world is reset in new_level().
  1590.   
  1591.   if (!polCorrect)
  1592.     {
  1593.       ostrstream msg;
  1594.       msg << wittySayings[Utils::choose(WITTY_SAYINGS_NUM)] << ends;
  1595.       locator.message_enq(msg.str());
  1596.     }
  1597.  
  1598.   /* Don't need to call Ui::set_* because the new values originally came 
  1599.      from Ui. */
  1600.  
  1601.   gameObjects.game_reset(oneItem,noItems,oneEach);
  1602.   style_reset();
  1603.   new_level(True);
  1604.   humans_reset(); // After new_level because world must be reset.
  1605.  
  1606.   gameOn = True;
  1607.  
  1608.   // Force Game::clock to set Ui::set_intels_playing().
  1609.   humansPlayingPrev = enemiesPlayingPrev = -1;  // Used to be 0.
  1610. }
  1611.  
  1612.  
  1613.  
  1614. void Game::process_x_resources(int *,char **)
  1615. {
  1616.   for (int dpyNum = 0; dpyNum < ui.get_dpy_max(); dpyNum++)
  1617.     if (!ui.keyset_set(dpyNum))
  1618.       {
  1619.     const char * const *keysNames = ui.get_keys_names();
  1620.     
  1621.     KeySym right[UI_KEYS_MAX][2],left[UI_KEYS_MAX][2];
  1622.     
  1623.     for (int n = 0; n < UI_KEYS_MAX; n++)
  1624.       for (int which = 0; which < 2; which++)
  1625.         {
  1626.           { // Right keys.
  1627.         right[n][which] = 0;
  1628.         
  1629.         ostrstream strm;
  1630.         if (which == 0)
  1631.           strm << "right_" << keysNames[n] << ends;
  1632.         else
  1633.           strm << "right_" << keysNames[n] << "_2" << ends;
  1634.         char *option = strm.str();
  1635.         
  1636.         // Should we free value??
  1637.         char *value = XGetDefault(ui.get_dpy(0),XEVIL_CLASS,option);
  1638.         if (value)
  1639.           {
  1640.             KeySym keysym = XStringToKeysym(value);
  1641.             if (keysym != NoSymbol)
  1642.               right[n][which] = keysym;
  1643.           }
  1644.         delete option;
  1645.           }
  1646.           
  1647.           { // Left Keys.
  1648.         left[n][which] = 0;
  1649.         
  1650.         ostrstream strm;
  1651.         if (which == 0)
  1652.           strm << "left_" << keysNames[n] << ends;
  1653.         else
  1654.           strm << "left_" << keysNames[n] << "_2" << ends;
  1655.         char *option = strm.str();
  1656.         
  1657.         // Should we free value??
  1658.         char *value = XGetDefault(ui.get_dpy(0),XEVIL_CLASS,option);
  1659.         if (value)
  1660.           {
  1661.             KeySym keysym = XStringToKeysym(value);
  1662.             if (keysym != NoSymbol)
  1663.               left[n][which] = keysym;
  1664.           }
  1665.         delete option;
  1666.           }
  1667.         }
  1668.     ui.set_keyset(dpyNum,KEYSET_DEFAULT,right,left);
  1669.       }
  1670. }
  1671.  
  1672.  
  1673.  
  1674. void Game::parse_args(int *argc,char **argv)
  1675. {
  1676.   for (int n = 0; n < *argc; n++)
  1677.     {
  1678.       if (! strcmp("-duel",argv[n]))
  1679.     {
  1680.       style = styleNext = UIsettings::DUEL;
  1681.       ui.set_style(style);
  1682.     }
  1683.       else if (! strcmp("-extended",argv[n]))
  1684.     {
  1685.       style = styleNext = UIsettings::EXTENDED;
  1686.       ui.set_style(style);
  1687.     }
  1688.       else if ((! strcmp("-h",argv[n])) || (! strcmp("-help",argv[n])))
  1689.     {
  1690.       cout 
  1691.         << "usage: " << argv[0] 
  1692.         << " [-display display_name] [-d<x> display_name | "
  1693.         << "-display<x> display_name] "
  1694.         << "[-duel] [-extended] [-h | -help] [-humans number] [-info] "
  1695.         << "[-kill] "
  1696.         << "[-keys alpha | decmips | iris | mac | ncd | rsaix | sun3 | sun4 "
  1697.         << "| sun4_sparc | tektronix] [-levels] [-machines number] [-map] "
  1698.         << "[-pc] [-regenerate_machines] [-rooms acrossxdown] "
  1699.         << "[-speed time-in-ms] [-synchronous] [-training]" << endl;
  1700.       exit(0);
  1701.     }
  1702.       else if (! strcmp("-harmless",argv[n]))
  1703.     intelHarmless = True;
  1704.       else if (!strcmp("-human_class",argv[n]) && (n + 1 < *argc))
  1705.     {
  1706.       assert(humanClass == A_None);
  1707.       n++;
  1708.       if (!strcmp("enforcer",argv[n]))
  1709.         humanClass = A_Enforcer;
  1710.       else if (!strcmp("frog",argv[n]))
  1711.         humanClass = A_Frog;
  1712.       else if (!strcmp("hero",argv[n]))
  1713.         humanClass = A_Hero;
  1714.       else if (!strcmp("ninja",argv[n]))
  1715.         humanClass = A_Ninja;
  1716.       else if (!strcmp("chopper-boy",argv[n]))
  1717.         humanClass = A_ChopperBoy;
  1718.       else if (!strcmp("alien",argv[n]))
  1719.         humanClass = A_Alien;
  1720.       else if (!strcmp("fire-demon",argv[n]))
  1721.         humanClass = A_FireDemon;
  1722.     }
  1723.       else if ((! strcmp("-humans",argv[n])) && (n + 1 < *argc))
  1724.     {
  1725.       humansNumNext = atoi(argv[n+1]);
  1726.       humansNumNext = min(humansNumNext,Locator::HUMANS_MAX);
  1727.       ui.set_humans_num(humansNumNext);
  1728.       n++;
  1729.     }
  1730.       else if (! strcmp("-info",argv[n]))
  1731.     {
  1732.       cout << 
  1733.       "   Copyright (C) 1994,1995  Steve Hardt " << endl << 
  1734.       endl << 
  1735.       "    This program is free software; you can redistribute it and/or modify" << endl <<
  1736.       "    it under the terms of the GNU General Public License as published by" << endl <<
  1737.       "    the Free Software Foundation; either version 1, or (at your option)" << endl <<
  1738.       "    any later version." << endl <<
  1739.       endl <<
  1740.       "    This program is distributed in the hope that it will be useful," << endl <<
  1741.       "    but WITHOUT ANY WARRANTY; without even the implied warranty of" << endl <<
  1742.       "    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the" << endl << 
  1743.       "    GNU General Public License for more details." << endl <<
  1744.       endl <<
  1745.       "    You should have received a copy of the GNU General Public License" << endl <<
  1746.       "    along with this program; if not, write to the Free Software" << endl <<
  1747.       "    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA." << endl <<
  1748.       endl <<
  1749.       "    Design and programming:" << endl <<
  1750.       "    Steve Hardt" << endl << 
  1751.           "    hardts@theory.lcs.mit.edu" << endl <<
  1752.           "    hardts@athena.mit.edu" << endl <<
  1753.       "    hardts@media.mit.edu" << 
  1754.       "    hardts@blake.3dem.bioch.bcm.tmc.edu" << endl <<
  1755.       "    2043 McClendon" << endl <<
  1756.       "    Houston, TX 77030" << endl << 
  1757.       endl <<
  1758.       "    The XEvil distribution is available via anonymous ftp at" << endl <<
  1759.       "    ftp.x.org under /contrib/games." << endl <<
  1760.       "    http://theory.lcs.mit.edu/~hardts/xevil.html" << endl;
  1761.       exit(0);
  1762.     }
  1763.       else if (! strcmp("-kill",argv[n]))
  1764.     {
  1765.       style = styleNext = UIsettings::KILL;
  1766.       ui.set_style(style);
  1767.     }
  1768.       else if ((! strcmp("-keys",argv[n])) && (n + 1 < *argc))
  1769.     {
  1770.       // Sets the keyset for all displays to the same value.
  1771.       n++;
  1772.       for (int dpyNum = 0; dpyNum < ui.get_dpy_max(); dpyNum++)
  1773.         {
  1774.           if (! strcmp("alpha",argv[n]))
  1775.         ui.set_keyset(dpyNum,UIalpha);
  1776.           if (! strcmp("decmips",argv[n]))
  1777.         ui.set_keyset(dpyNum,UIdecmips);
  1778.           if (! strcmp("iris",argv[n]))
  1779.         ui.set_keyset(dpyNum,UIiris);
  1780.           if (! strcmp("mac",argv[n]))
  1781.         ui.set_keyset(dpyNum,UImac);
  1782.           if (! strcmp("ncd",argv[n]))
  1783.         ui.set_keyset(dpyNum,UIncd);
  1784.           if (! strcmp("rsaix",argv[n]))
  1785.         ui.set_keyset(dpyNum,UIrsaix);
  1786.           if (! strcmp("sun3",argv[n]))
  1787.         ui.set_keyset(dpyNum,UIsun3);
  1788.           if (! strcmp("sun4",argv[n]))
  1789.         ui.set_keyset(dpyNum,UIsun4);
  1790.           if (! strcmp("sun4_sparc",argv[n]))
  1791.         ui.set_keyset(dpyNum,UIsun4_sparc);
  1792.           if (! strcmp("tektronix",argv[n]))
  1793.         ui.set_keyset(dpyNum,UItektronix);
  1794.         }
  1795.     }
  1796.       else if (!strcmp("-levels",argv[n]))
  1797.     {
  1798.       style = styleNext = UIsettings::LEVELS;
  1799.       ui.set_style(style);
  1800.     }
  1801.       else if ((! strcmp("-machines",argv[n])) && (n + 1 < *argc))
  1802.     {
  1803.       enemiesNumNext = atoi(argv[n+1]);
  1804.       enemiesNumNext = min(enemiesNumNext,Locator::ENEMIES_MAX);
  1805.       ui.set_enemies_num(enemiesNumNext);
  1806.       n++;
  1807.     }
  1808.       else if (! strcmp("-map",argv[n]))
  1809.     world.set_map_print(True);
  1810.       else if (! strcmp("-no_items",argv[n]))
  1811.     noItems = True;
  1812.       else if (! strcmp("-one_each",argv[n]))
  1813.     oneEach = True;
  1814.       else if ((! strcmp("-one_item",argv[n])) && (n + 1 < *argc))
  1815.     {
  1816.       n++;
  1817.       oneItem = argv[n];
  1818.     }
  1819.       /* "-pc" command line option handled by Game::is_pol_correct. */
  1820.       else if (! strcmp("-regenerate_machines",argv[n]))
  1821.     {
  1822.       enemiesRefillNext = True;
  1823.       ui.set_enemies_refill(True);
  1824.     }
  1825.       else if (! strcmp("-rooms",argv[n]) && (n + 1 < *argc))
  1826.     {
  1827.       Rooms temp;
  1828.       if (sscanf(argv[n+1],"%dx%d",
  1829.              &temp.acrossMax,&temp.downMax) == 2)
  1830.         worldRooms = temp;
  1831.       n++;
  1832.     }
  1833.       else if ((! strcmp("-scenario",argv[n])) && (n + 1 < *argc))
  1834.     {
  1835.       n++;
  1836.       if (!(strcmp("exterminate",argv[n])))
  1837.         scenarioOverride = EXTERMINATE;
  1838.       else if (!(strcmp("flag",argv[n])))
  1839.         scenarioOverride = FLAG;
  1840.       else if (!(strcmp("bonus",argv[n])))
  1841.         scenarioOverride = BONUS;
  1842.       else if (!(strcmp("hive",argv[n])))
  1843.         scenarioOverride = HIVE;
  1844.       else if (!(strcmp("lems",argv[n])))
  1845.         scenarioOverride = LEMMINGS;
  1846.       else if (!(strcmp("fire-demon",argv[n])))
  1847.         scenarioOverride = FIRE_DEMON;
  1848.     }
  1849.       else if (!strcmp("-scenarios",argv[n]))
  1850.     {
  1851.       style = styleNext = UIsettings::SCENARIOS;
  1852.       ui.set_style(style);
  1853.     }
  1854.       else if ((! strcmp("-speed",argv[n])) && (n + 1 < *argc))
  1855.     {
  1856.       quanta = atoi(argv[n+1]);
  1857.       ui.set_quanta(quanta);
  1858.       n++;
  1859.     }
  1860.       else if (! strcmp("-stats",argv[n]))
  1861.     showStats = True;
  1862.       else if (! strcmp("-synchronous",argv[n]))
  1863.     for (int m = 0; m < ui.get_dpy_max(); m++)
  1864.       XSynchronize(ui.get_dpy(m),True);
  1865.       else if (! strcmp("-training",argv[n]))
  1866.     {
  1867.       style = styleNext = UIsettings::TRAINING;
  1868.       ui.set_style(style);
  1869.     }
  1870.     }
  1871. }
  1872.  
  1873.  
  1874.  
  1875. Boolean Game::is_pol_correct(int *argc,char **argv)
  1876. {
  1877.   for (int n = 0; n < *argc; n++)
  1878.     if (! strcmp("-pc",argv[n]))
  1879.       return True;
  1880.  
  1881.   return False;
  1882. }
  1883.  
  1884.  
  1885.  
  1886. char **Game::display_names(int *argc,char **argv)
  1887. {
  1888.   ostrstream dashDisplay[UI_VIEWPORTS_MAX][2];
  1889.   typedef char *charP;
  1890.   char **displayNames = new charP [UI_VIEWPORTS_MAX];
  1891.  
  1892.   for (int n = 0; n < UI_VIEWPORTS_MAX; n++)
  1893.     {
  1894.       displayNames[n] = new char [Xvars::DISPLAY_NAME_LENGTH];
  1895.       strcpy(displayNames[n],"");
  1896.       dashDisplay[n][0] << "-display" << n << ends;
  1897.       dashDisplay[n][1] << "-d" << n << ends;
  1898.     }
  1899.  
  1900.   // Loop through all command line arguments.
  1901.   for (n = 0; n < *argc - 1 ; n++)
  1902.     {
  1903.       // Set display name for all viewports.
  1904.       if (!strcmp(argv[n],"-display") || !strcmp(argv[n],"-d"))
  1905.     {
  1906.       assert(strlen(argv[n+1]) < Xvars::DISPLAY_NAME_LENGTH);
  1907.       for (int vNum = 0; vNum < UI_VIEWPORTS_MAX; vNum++)
  1908.         strcpy(displayNames[vNum],argv[n+1]);
  1909.     }
  1910.       
  1911.       // Set display name for one viewport.
  1912.       for (int m = 0; m < UI_VIEWPORTS_MAX; m++)
  1913.     for (int which = 0; which < 2; which++)
  1914.       if (!strcmp(argv[n],dashDisplay[m][which].str()))
  1915.         {
  1916.           assert(strlen(argv[n+1]) < Xvars::DISPLAY_NAME_LENGTH);
  1917.           strcpy(displayNames[m],argv[n+1]);
  1918.         }
  1919.     }
  1920.  
  1921.   for (n = 0; n < UI_VIEWPORTS_MAX; n++)
  1922.     for (int which = 0; which < 2; which++)
  1923.       delete dashDisplay[n][which].str();
  1924.  
  1925.   return displayNames;
  1926. }
  1927.  
  1928.  
  1929.  
  1930. void Game::humans_reset()
  1931. {
  1932.   assert(humansNum <= Xvars::HUMAN_COLORS_NUM);
  1933.   assert(humansNum <= Locator::HUMANS_MAX);
  1934.  
  1935.   // Doesn't really have to be done if polCorrect.
  1936.   assert(humansNum <= INTEL_NAMES_NUM);
  1937.   int intelNamesIndices[INTEL_NAMES_NUM];
  1938.   Utils::randomList(intelNamesIndices,INTEL_NAMES_NUM);
  1939.  
  1940.  
  1941.   // Create humans along with their viewports, if necessary.
  1942.   for (int vn = 0; vn < humansNum; vn++)
  1943.     {
  1944.       assert(vn <= ui.get_viewports_num());
  1945.       if (vn == ui.get_viewports_num())
  1946.     {
  1947.       int vNum = ui.add_viewport();
  1948.       assert(vn == vNum);
  1949.       int v = ui.get_viewports_num_on_dpy(ui.get_dpy_num(vNum));
  1950.       if (v == 1)
  1951.         ui.set_input(vNum,UI_KEYS_RIGHT);
  1952.       else if (v == 2)
  1953.         ui.set_input(vNum,UI_KEYS_LEFT);
  1954.     }
  1955.       ostrstream namePc;
  1956.       if (polCorrect)
  1957.     namePc << "Human-" << vn << ends;
  1958.  
  1959.       // Give infinite lives for UIsettings::EXTENDED.
  1960.       // Not infinite lives for Uisettings::DUEL.
  1961.       int lives = (style == UIsettings::EXTENDED) ? IT_INFINITE_LIVES : 
  1962.       (style == UIsettings::SCENARIOS ? HUMAN_LIVES_SCENARIOS :
  1963.        HUMAN_LIVES);
  1964.  
  1965.       HumanP human = 
  1966.     new Human(&world,&locator,
  1967.           (polCorrect?namePc.str():intelNames[intelNamesIndices[vn]]),
  1968.           lives,vn);
  1969.       
  1970.       assert(human);
  1971.       if (polCorrect)
  1972.     delete namePc.str();
  1973.  
  1974.       locator.register_human(human);
  1975.       ui.register_intel(vn,human);
  1976.  
  1977.       // Actual objects for humans.
  1978.       PhysicalP obj= human_physical();
  1979.       locator.add(obj);
  1980.       obj->set_intel(human);
  1981.     }
  1982.  
  1983.   int delNum = ui.get_viewports_num() - humansNum;
  1984.   for (int n = 0; n < delNum; n++)
  1985.     if (ui.get_viewports_num() > 1)
  1986.       ui.del_viewport();
  1987. }
  1988.  
  1989.  
  1990.  
  1991. void Game::style_reset()
  1992. {
  1993.   // So first level will start out with LEVEL_ENEMIES_INITIAL.
  1994.   if (style == UIsettings::SCENARIOS || style == UIsettings::LEVELS)
  1995.     enemiesNum = LEVEL_ENEMIES_INITIAL - LEVEL_ENEMIES_INCR;
  1996.     
  1997.   if (style == UIsettings::KILL || style == UIsettings::DUEL 
  1998.        || style == UIsettings::EXTENDED)
  1999.     for (int m = 0; m < enemiesNum; m++)
  2000.       create_enemy();
  2001.  
  2002.   
  2003.   if ((style == UIsettings::DUEL || style == UIsettings::EXTENDED) 
  2004.       && humansNum < 2)
  2005.     {
  2006.       ostrstream str;
  2007.       str << "!!!!!!!! YOU NEED AT LEAST 2 HUMAN PLAYERS FOR A "
  2008.       << "DUEL !!!!!!!!" << ends;
  2009.       locator.message_enq(str.str());
  2010.     }
  2011. }
  2012.  
  2013.  
  2014.  
  2015. void Game::intro()
  2016. {
  2017.   ostrstream msg;
  2018.   msg << "XEvil version " << VERSION 
  2019.     << ", Copyright (C) 1994,1995 Steve Hardt (hardts@theory.lcs.mit.edu)" 
  2020.       << "\n" << "http://theory.lcs.mit.edu/~hardts/xevil.html" << ends;
  2021.   locator.message_enq(msg.str());
  2022.   
  2023.   cout << "XEvil version " << VERSION << 
  2024.     ", Copyright (C) 1994,1995 Steve Hardt" << endl <<
  2025.           "hardts@theory.lcs.mit.edu" << endl <<
  2026.           "hardts@athena.mit.edu" << endl <<
  2027.       "hardts@media.mit.edu" << endl << 
  2028.       "hardts@blake.3dem.bioch.bcm.tmc.edu" << endl;
  2029.   cout << "XEvil comes with ABSOLUTELY NO WARRANTY." << endl;
  2030.   
  2031.   cout << "Type 'xevil -info' for information on redistribution and " 
  2032.     << "on NO WARRANTY." << endl;
  2033.   cout << "The XEvil distribution can be found at ftp.x.org under /contrib/games." << endl;
  2034.   cout << "http://theory.lcs.mit.edu/~hardts/xevil.html" << endl;
  2035. }
  2036.  
  2037.  
  2038.  
  2039. void Game::print_stats()
  2040. {
  2041.   const Stats &shot = Shot::get_stats();
  2042.   const Stats &grenade = Grenade::get_stats();
  2043.   const Stats &doppel = Doppel::get_stats();
  2044.   const Stats &transmogifier = Transmogifier::get_stats();
  2045.   const Stats &medKit = MedKit::get_stats();
  2046.   const Stats &shield = Shield::get_stats();
  2047.   const Stats &bomb = Bomb::get_stats();
  2048.   const Stats &creature = Creature::get_stats();
  2049.   const Stats &enforcer = Enforcer::get_stats();
  2050.   const Stats &frog = Frog::get_stats();
  2051.   const Stats &hero = Hero::get_stats();
  2052.   const Stats &ninja = Ninja::get_stats();
  2053.   const Stats &alien = Alien::get_stats();
  2054.   const Stats &chopperBoy = ChopperBoy::get_stats();
  2055.   const Stats &lemming = Lemming::get_stats();
  2056.  
  2057.   cout << setprecision(3) << endl
  2058.   << "-----------------------STATISTICS-----------------------" << endl
  2059.   << "Shots fired:                               " 
  2060.   << shot.get_creations() << endl
  2061.   << "Grenades thrown:                           " 
  2062.   << grenade.get_creations() << endl
  2063.   << "Doppelgangers used:                        " 
  2064.   << doppel.get_uses() << endl
  2065.   << "Transmogifiers used:                       " 
  2066.   << transmogifier.get_uses() << endl
  2067.   << "MedKits used:                              " 
  2068.   << medKit.get_uses() << endl
  2069.   << "Shields used:                              " 
  2070.   << shield.get_uses() << endl
  2071.   << "Bombs exploded:                            " 
  2072.   << bomb.get_uses() << endl
  2073.   << "Creatures killed (average lifespan):       " 
  2074.   << creature.get_deaths() << "  (" << creature.get_ave_lifespan() 
  2075.   << " sec)" << endl
  2076.   << "   Enforcers:                              " 
  2077.   << enforcer.get_deaths() 
  2078.   << "  (" << enforcer.get_ave_lifespan() << " sec)" << endl
  2079.   << "   Frogs:                                  " << frog.get_deaths()
  2080.   << "  (" << frog.get_ave_lifespan() << " sec)" << endl
  2081.   << "   Heros:                                  " << hero.get_deaths()
  2082.   << "  (" << hero.get_ave_lifespan() << " sec)" << endl
  2083.   << "   Ninjas:                                 " << ninja.get_deaths()
  2084.   << "  (" << ninja.get_ave_lifespan() << " sec)" << endl
  2085.   << "   Aliens:                                 " << alien.get_deaths()
  2086.   << "  (" << alien.get_ave_lifespan() << " sec)" << endl
  2087.   << "   ChopperBoys:                            " 
  2088.   << chopperBoy.get_deaths()
  2089.   << "  (" << chopperBoy.get_ave_lifespan() << " sec)" << endl
  2090.   << "   Lems:                                   " 
  2091.   << lemming.get_deaths()
  2092.   << "  (" << lemming.get_ave_lifespan() << " sec)" << endl
  2093.   << "Highest level:                             " << levelHighest << endl;
  2094. }
  2095.  
  2096.  
  2097.  
  2098. void Game::refill_enemies()
  2099. {
  2100.   int diff = enemiesNum - locator.enemies_alive();
  2101.   assert(diff >= 0);
  2102.   
  2103.   for (int n = 0; n < diff; n++)
  2104.     create_enemy();
  2105. }
  2106.  
  2107.  
  2108.  
  2109. void Game::hive_refill_enemies()
  2110. {
  2111.   int diff = SCENARIO_HIVE_ALIENS - locator.enemies_alive();
  2112.   assert(diff >= 0);
  2113.  
  2114.   for (int n = 0; n < diff; n++)
  2115.     create_enemy(enemy_physical(A_Alien));
  2116. }
  2117.  
  2118.  
  2119.  
  2120. void Game::flag_refill_enemies()
  2121. {
  2122.   int diff = SCENARIO_FLAG_ENEMIES - locator.enemies_alive();
  2123.   assert(diff >= 0);
  2124.   
  2125.   for (int n = 0; n < diff; n++)
  2126.     create_enemy();
  2127. }
  2128.  
  2129.  
  2130.  
  2131. void Game::lemmings_refill_enemies()
  2132. {
  2133.   int diff = SCENARIO_LEMMINGS_ENEMIES - locator.enemies_alive();
  2134.   assert(diff >= 0);
  2135.   
  2136.   // Change the num argument to enemy_physical if this list is changed.
  2137.   int list[] = {A_Ninja,A_Hero,A_ChopperBoy};
  2138.  
  2139.   for (int n = 0; n < diff; n++)
  2140.     create_enemy(enemy_physical(list,3));
  2141. }
  2142.  
  2143.  
  2144.  
  2145. PhysicalP Game::create_enemy(PhysicalP obj)
  2146. {
  2147.   if (!obj)
  2148.     obj = enemy_physical();
  2149.  
  2150.   IntelOptions ops;
  2151.   ops.harmless = intelHarmless;
  2152.   ops.classFriends = (style != UIsettings::KILL);
  2153.   ops.psychotic = obj->get_class_id() == A_Enforcer || 
  2154.     obj->get_class_id() == A_Alien ||
  2155.       obj->get_class_id() == A_FireDemon;
  2156.   
  2157.   ostrstream name;
  2158.   name << "Machine-" << (enemyNameCount++) << ends;
  2159.   char *nameStr = name.str();
  2160.   EnemyP enemy = new Enemy(&world,&locator,nameStr,&ops,
  2161.                  ITharmless | ITclassFriends | ITpsychotic);
  2162.   assert(enemy);
  2163.   delete nameStr;
  2164.   locator.register_enemy(enemy);
  2165.  
  2166.   locator.add(obj);
  2167.   obj->set_intel(enemy);
  2168.  
  2169.   return obj;
  2170. }
  2171.  
  2172.  
  2173.  
  2174. void Game::demo_setup()
  2175. {
  2176.   // Choose between different demos.
  2177.   switch (Utils::choose(6))  
  2178.     {
  2179.     case 0:  // A bunch of Heros and an Alien.
  2180.       {
  2181.     for (int n = 0; n < 10; n++)
  2182.       {
  2183.         ostrstream name;
  2184.         name << "Enemy-" << n << ends;
  2185.         IntelOptions ops;
  2186.         ops.harmless = True;
  2187.         EnemyP enemy = new Enemy(&world,&locator,name.str(),
  2188.                        &ops,ITharmless);
  2189.         assert(enemy);
  2190.         delete name.str();
  2191.         locator.register_enemy(enemy);
  2192.         
  2193.         Pos pos = world.empty_rect(Hero::get_size_max());
  2194.         PhysicalP obj = new Hero(&world,&locator,pos);
  2195.         assert(obj);
  2196.         locator.add(obj);
  2197.         obj->set_intel(enemy);
  2198.       }
  2199.     IntelOptions ops;
  2200.     ops.psychotic = True;
  2201.     EnemyP enemy = new Enemy(&world,&locator,"killer",&ops,ITpsychotic);
  2202.     assert(enemy);
  2203.     locator.register_enemy(enemy);
  2204.     Pos pos = world.empty_rect(Alien::get_size_max());
  2205.     PhysicalP obj = new Alien(&world,&locator,pos);
  2206.     assert(obj);
  2207.     locator.add(obj);
  2208.     obj->set_intel(enemy);
  2209.       }
  2210.       break;
  2211.     case 1: // Hero, FThrower, and a bunch of Frogs (does not mean Frenchmen).
  2212.       {
  2213.     for (int n = 0; n < 15; n++)
  2214.       {
  2215.         ostrstream name;
  2216.         name << "Enemy-" << n << ends;
  2217.         IntelOptions ops;
  2218.         ops.psychotic = Utils::coinFlip();
  2219.         EnemyP enemy = new Enemy(&world,&locator,name.str(),
  2220.                        &ops,ITpsychotic);
  2221.         assert(enemy);
  2222.         delete name.str();
  2223.         locator.register_enemy(enemy);
  2224.         
  2225.         Pos pos = world.empty_rect(Frog::get_size_max());
  2226.         Id invalid;
  2227.         PhysicalP obj = new Frog(&world,&locator,pos,invalid);
  2228.         assert(obj);
  2229.         locator.add(obj);
  2230.         obj->set_intel(enemy);
  2231.       }
  2232.  
  2233.     EnemyP enemy = new Enemy(&world,&locator,"killer",NULL,0);
  2234.     assert(enemy);
  2235.     locator.register_enemy(enemy);
  2236.     Pos pos = world.empty_rect(Hero::get_size_max());
  2237.     PhysicalP obj = new Hero(&world,&locator,pos);
  2238.     assert(obj);
  2239.     locator.add(obj);
  2240.     obj->set_intel(enemy);
  2241.     
  2242. //    pos = world.empty_rect(FThrower::get_size_max());
  2243.     PhysicalP fThrower = new FThrower(&world,&locator,pos);
  2244.     locator.add(fThrower);
  2245.       }
  2246.       break;
  2247.     case 2: // A bunch of Enforcers.
  2248.       {
  2249.     for (int n = 0; n < 10; n++)
  2250.       {
  2251.         ostrstream name;
  2252.         name << "Enemy-" << n << ends;
  2253.         IntelOptions ops;
  2254.         ops.classFriends = False;
  2255.         ops.psychotic = True;
  2256.         EnemyP enemy = new Enemy(&world,&locator,name.str(),
  2257.                        &ops,ITclassFriends|ITpsychotic);
  2258.         assert(enemy);
  2259.         delete name.str();
  2260.         locator.register_enemy(enemy);
  2261.         
  2262.         Pos pos = world.empty_rect(Enforcer::get_size_max());
  2263.         PhysicalP obj = new Enforcer(&world,&locator,pos);
  2264.         assert(obj);
  2265.         locator.add(obj);
  2266.         obj->set_intel(enemy);
  2267.       }
  2268.       }
  2269.       break;
  2270.     case 3: // A bunch of Ninjas.
  2271.       {
  2272.     for (int n = 0; n < 10; n++)
  2273.       {
  2274.         ostrstream name;
  2275.         name << "Enemy-" << n << ends;
  2276.         IntelOptions ops;
  2277.         ops.classFriends = False;
  2278.         EnemyP enemy = new Enemy(&world,&locator,name.str(),
  2279.                        &ops,ITclassFriends);
  2280.         assert(enemy);
  2281.         delete name.str();
  2282.         locator.register_enemy(enemy);
  2283.         
  2284.         Pos pos = world.empty_rect(Ninja::get_size_max());
  2285.         PhysicalP obj = new Ninja(&world,&locator,pos);
  2286.         assert(obj);
  2287.         locator.add(obj);
  2288.         obj->set_intel(enemy);
  2289.       }
  2290.     Pos pos = world.empty_rect(Chainsaw::get_size_max());
  2291.     PhysicalP obj = new Chainsaw(&world,&locator,pos);
  2292.     locator.add(obj);
  2293.       }
  2294.       break;
  2295.     case 4: // drop weights 
  2296.       {
  2297.     for (int n = 0; n < 36; n++)
  2298.       {
  2299.         Pos pos(32 + 16 * n,16 * 6);
  2300.         Pos pos2(32 + 16 * n,32);
  2301.         PhysicalP p = new Weight(&world,&locator,pos);
  2302.         PhysicalP p2 = new Bomb(&world,&locator,pos2);
  2303.         ((ItemP)p2)->use(NULL);
  2304.  
  2305.         Vel vel(0,-12);
  2306.         ((MovingP)p)->set_vel_next(vel);
  2307.         locator.add(p);
  2308.         locator.add(p2);
  2309.       }        
  2310.  
  2311.     for (int m = 0; m < 10; m++)
  2312.       {
  2313.         ostrstream name;
  2314.         name << "Enemy-" << m << ends;
  2315.         EnemyP enemy = new Enemy(&world,&locator,name.str(),
  2316.                        NULL,ITnone);
  2317.         assert(enemy);
  2318.         delete name.str();
  2319.         locator.register_enemy(enemy);
  2320.         
  2321.         Pos pos(32 + Utils::choose(16 * 36),16 * 12);
  2322.         PhysicalP obj;
  2323.         switch (Utils::choose(3)) {
  2324.         case 0:
  2325.           obj = new Ninja(&world,&locator,pos);
  2326.           break;
  2327.         case 1:
  2328.           obj = new Hero(&world,&locator,pos);
  2329.           break;
  2330.         case 2:
  2331.           {
  2332.         Id invalid;
  2333.         obj = new Frog(&world,&locator,pos,invalid);
  2334.           }
  2335.           break;
  2336.         };
  2337.         assert(obj);
  2338.         locator.add(obj);
  2339.         obj->set_intel(enemy);
  2340.       }
  2341.       }
  2342.       break;
  2343.     case 5: // Ninjas and ChopperBoys.
  2344.       {
  2345.     for (int n = 0; n < 10; n++)
  2346.       {
  2347.         ostrstream name;
  2348.         name << "Enemy-" << n << ends;
  2349.         IntelOptions ops;
  2350.         ops.classFriends = False;
  2351.         EnemyP enemy = new Enemy(&world,&locator,name.str(),
  2352.                        &ops,ITclassFriends);
  2353.         assert(enemy);
  2354.         delete name.str();
  2355.         locator.register_enemy(enemy);
  2356.         
  2357.         PhysicalP obj;
  2358.         Pos pos;
  2359.         if (n % 2)
  2360.           {
  2361.         pos = world.empty_rect(Ninja::get_size_max());
  2362.         obj = new Ninja(&world,&locator,pos);
  2363.           }
  2364.         else
  2365.           {
  2366.         pos = world.empty_rect(ChopperBoy::get_size_max());
  2367.         obj = new ChopperBoy(&world,&locator,pos);
  2368.           }
  2369.         assert(obj);
  2370.         locator.add(obj);
  2371.         obj->set_intel(enemy);
  2372.       }
  2373.     for (n = 0; n < 5; n++)
  2374.       {
  2375.         Pos pos = world.empty_rect(Launcher::get_size_max());
  2376.         PhysicalP obj = new Launcher(&world,&locator,pos);
  2377.         assert(obj);
  2378.         locator.add(obj);
  2379.       }
  2380.  
  2381.       }
  2382.       break;
  2383.     default:
  2384.       assert(0);
  2385.     };
  2386. }
  2387.  
  2388.  
  2389.  
  2390. void Game::off_clock_kill(PhysicalP p)
  2391. {
  2392. //  cout << "attempting to kill " << p->identify() << endl;
  2393.  
  2394.   p->set_quiet_death();
  2395.   if (!p->die_called())
  2396.     {
  2397.       p->kill_self();
  2398.       p->die();
  2399.     }
  2400. }
  2401.  
  2402.